A programmable integrated circuit (IC) is a well-known type of integrated circuit that can be programmed to perform, e.g., specified logic functions. One type of programmable IC, the field programmable gate array (FPGA), typically includes an array of programmable tiles. These programmable tiles can include, for example, input/output blocks (IOBs), configurable logic blocks (CLBs), dedicated random access memory blocks (BRAM), multipliers, digital signal processing blocks (DSPs), processors, clock managers, delay lock loops (DLLs), and so forth.
Each programmable tile typically includes both programmable interconnect and programmable logic. The programmable interconnect typically includes a large number of interconnect lines of varying lengths interconnected by programmable interconnect points (PIPs). The programmable logic implements the logic of a user design using programmable elements that can include, for example, function generators, registers, arithmetic logic, and so forth.
The programmable interconnect and programmable logic are typically programmed by loading a stream of configuration data, referred to as a bitstream, into internal configuration memory cells that define how the programmable elements are configured. The configuration data can be read from memory (e.g., from an external PROM) or written into the FPGA by an external device. The collective states of the individual memory cells then determine the function of the FPGA.
Another type of programmable IC is the complex programmable logic device, or CPLD. A CPLD includes two or more “function blocks” connected together and to input/output (I/O) resources by an interconnect switch matrix. Each function block of the CPLD includes a two-level AND/OR structure similar to those used in programmable logic arrays and programmable array logic devices. In CPLDs, configuration data is typically stored on-chip in non-volatile memory. In some CPLDs, configuration data is stored on-chip in non-volatile memory, then downloaded to volatile memory as part of an initial configuration (programming) sequence.
For all of these programmable ICs, the functionality of the device is controlled by data bits provided to the device for that purpose. The data bits can be stored in volatile memory (e.g., static memory cells, as in FPGAs and some CPLDs), in non-volatile memory (e.g., FLASH memory, as in some CPLDs), or in any other type of memory cell.
Programmable ICs can also be implemented in other ways, e.g., using fuse or antifuse technology. The phrase “programmable IC” can include, but is not limited to, these devices and further can encompass devices that are only partially programmable. For example, one type of programmable IC includes a combination of hard-coded transistor logic and a programmable switch fabric that programmably interconnects the hard-coded transistor logic.
Accordingly, to instantiate a circuit design, or a portion of a circuit design, within a programmable IC, a bitstream is loaded into the configuration memory cells of the device. In some cases, a problem can occur when loading the bitstream into the programmable IC. For example, communication between the source from which the bitstream is provided and the programmable IC can be interrupted resulting in the programmable IC not receiving any bitstream data bits or receiving only a portion of the bitstream data bits. In another example, the data bits of the bitstream can be corrupted resulting in either incomplete or incorrect data bits being provided to the programmable IC. Detecting such problems during the bitstream loading process can be important for several reasons. One reason is that an incomplete or incorrect bitstream can result in a non-functioning or malfunctioning programmable IC. Another reason is that an incomplete or incorrect bitstream can cause damage to the programmable IC.